home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / psychic5.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  19KB  |  768 lines
  1. /***************************************************************************
  2.   Psychic 5
  3.  
  4.   Functions to emulate the video hardware of the machine.
  5.  
  6. ***************************************************************************/
  7.  
  8. #include "driver.h"
  9. #include "vidhrdw/generic.h"
  10.  
  11.  
  12. #define    BG_SCROLLX_LSB        0x308
  13. #define    BG_SCROLLX_MSB        0x309
  14. #define    BG_SCROLLY_LSB        0x30a
  15. #define    BG_SCROLLY_MSB        0x30b
  16. #define    BG_SCREEN_MODE        0x30c
  17. #define    BG_PAL_INTENSITY_RG    0x1fe
  18. #define    BG_PAL_INTENSITY_BU    0x1ff
  19.  
  20. static int          ps5_vram_page = 0x0;
  21. static int         bg_clip_mode;
  22.  
  23. static struct osd_bitmap *bitmap_bg;
  24. static unsigned char      *bg_dirtybuffer;
  25.  
  26. /* Paged RAM 0 */
  27. static unsigned char       *ps5_background_videoram;
  28. static unsigned char       *ps5_dummy_bg_ram;
  29.  
  30. /* Paged RAM 1 */
  31. static unsigned char      *ps5_io_ram;
  32. static unsigned char      *ps5_palette_ram;
  33. static unsigned char      *ps5_foreground_videoram;
  34.  
  35.  
  36. int is_psychic5_title_mode(void)
  37. {
  38.     if (ps5_foreground_videoram[0x7C6]=='H') return 0;
  39.     return 1;
  40. }
  41.  
  42. void psychic5_init_machine(void)
  43. {
  44.     bg_clip_mode = -10;
  45. }
  46.  
  47. WRITE_HANDLER( psychic5_vram_page_select_w )
  48. {
  49.     ps5_vram_page = data;
  50. }
  51.  
  52. READ_HANDLER( psychic5_vram_page_select_r )
  53. {
  54.     return ps5_vram_page;
  55. }
  56.  
  57. void psychic5_paletteram_w(int color_offs, int offset, int data)
  58. {
  59.     int bit0,bit1,bit2,bit3;
  60.     int r,g,b,val;
  61.  
  62.     ps5_palette_ram[offset] = data;
  63.  
  64.     /* red component */
  65.     val  = ps5_palette_ram[offset & ~1] >> 4;
  66.     bit0 = (val >> 0) & 0x01;
  67.     bit1 = (val >> 1) & 0x01;
  68.     bit2 = (val >> 2) & 0x01;
  69.     bit3 = (val >> 3) & 0x01;
  70.     r = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  71.  
  72.     /* green component */
  73.     val = ps5_palette_ram[offset & ~1];
  74.     bit0 = (val >> 0) & 0x01;
  75.     bit1 = (val >> 1) & 0x01;
  76.     bit2 = (val >> 2) & 0x01;
  77.     bit3 = (val >> 3) & 0x01;
  78.     g = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  79.  
  80.     /* blue component */
  81.     val = ps5_palette_ram[offset | 1] >> 4;
  82.     bit0 = (val >> 0) & 0x01;
  83.     bit1 = (val >> 1) & 0x01;
  84.     bit2 = (val >> 2) & 0x01;
  85.     bit3 = (val >> 3) & 0x01;
  86.     b = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  87.  
  88.     palette_change_color((offset / 2)-color_offs,r,g,b);
  89. }
  90.  
  91. void set_background_palette_intensity(void)
  92. {
  93.     int i,r,g,b,val,lo,hi,ir,ig,ib,ix;
  94.     int bit0,bit1,bit2,bit3;
  95.  
  96.     /* red,green,blue intensites */
  97.     ir = 15 - (ps5_palette_ram[BG_PAL_INTENSITY_RG] >> 4);
  98.     ig = 15 - (ps5_palette_ram[BG_PAL_INTENSITY_RG] & 15);
  99.     ib = 15 - (ps5_palette_ram[BG_PAL_INTENSITY_BU] >> 4);
  100.     /* unknow but assumes value 2 during the ride on the witches' broom */
  101.     ix = ps5_palette_ram[0x1ff] & 15;
  102.  
  103.     for (i=0; i<256; i++)
  104.     {
  105.         lo = ps5_palette_ram[0x400+i*2];
  106.         hi = ps5_palette_ram[0x400+i*2+1];
  107.  
  108.         val  =  lo >> 4;
  109.         bit0 = (val >> 0) & 0x01;
  110.         bit1 = (val >> 1) & 0x01;
  111.         bit2 = (val >> 2) & 0x01;
  112.         bit3 = (val >> 3) & 0x01;
  113.  
  114.         r = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  115.  
  116.         /* green component */
  117.         val = lo & 15;
  118.         bit0 = (val >> 0) & 0x01;
  119.         bit1 = (val >> 1) & 0x01;
  120.         bit2 = (val >> 2) & 0x01;
  121.         bit3 = (val >> 3) & 0x01;
  122.  
  123.         g = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  124.  
  125.         /* blue component */
  126.         val = hi >> 4;
  127.         bit0 = (val >> 0) & 0x01;
  128.         bit1 = (val >> 1) & 0x01;
  129.         bit2 = (val >> 2) & 0x01;
  130.         bit3 = (val >> 3) & 0x01;
  131.  
  132.         b = 0x0e * bit0 + 0x1f * bit1 + 0x43 * bit2 + 0x8f * bit3;
  133.  
  134.         /* grey background enable */
  135.  
  136.         if (ps5_io_ram[BG_SCREEN_MODE] & 2)
  137.         {
  138.             val = (unsigned char)(0.299*r + 0.587*g + 0.114*b);
  139.  
  140.              if (ix==2)        /* purple background enable */
  141.              palette_change_color(256+i,val*0.6,0,val*0.8);
  142.             else            /* grey bg */
  143.              palette_change_color(256+i,val,val,val);
  144.         }
  145.         else
  146.         {
  147.  
  148.             /* background intensity enable  TO DO BETTER !!! */
  149.  
  150.             if (!is_psychic5_title_mode())
  151.             {
  152.                 r = (r>>4) * ir;
  153.                    g = (g>>4) * ig;
  154.                    b = (b>>4) * ib;
  155.             }
  156.             palette_change_color(256+i,r,g,b);
  157.         }
  158.     }
  159. }
  160.  
  161.  
  162. WRITE_HANDLER( psychic5_bgvideoram_w )
  163. {
  164.     if (ps5_background_videoram[offset] != data)
  165.     {
  166.         bg_dirtybuffer[offset >> 1] = 1;
  167.         ps5_background_videoram[offset] = data;
  168.     }
  169. }
  170.  
  171. READ_HANDLER( psychic5_paged_ram_r )
  172. {
  173.     int val;
  174.  
  175.     if (!ps5_vram_page)
  176.     {
  177.  
  178.         if (offset < 0x1000)
  179.             return ps5_background_videoram[offset];
  180.         else
  181.             return ps5_dummy_bg_ram[offset & 0xfff];
  182.  
  183.     } else
  184.     {
  185.         if (offset < 0x400)
  186.         {
  187.             val = 0;
  188.             switch(offset)
  189.             {
  190.                 case 0x00:
  191.                     val = input_port_0_r(0);
  192.                     break;
  193.                 case 0x01:
  194.                     val = input_port_1_r(0);
  195.                     break;
  196.                 case 0x02:
  197.                     val = input_port_2_r(0);
  198.                     break;
  199.                 case 0x03:
  200.                     val = input_port_3_r(0);
  201.                     break;
  202.                 case 0x04:
  203.                     val = input_port_4_r(0);
  204.                     break;
  205.                 default:
  206.                     val = ps5_io_ram[offset];
  207.             }
  208.             return (val);
  209.         }
  210.         else if (offset < 0x1000)
  211.         {
  212.             return ps5_palette_ram[offset-0x400];
  213.         }
  214.         else
  215.         {
  216.             return ps5_foreground_videoram[offset & 0xfff];
  217.         }
  218.     }
  219.     return 0;
  220. }
  221.  
  222. WRITE_HANDLER( psychic5_paged_ram_w )
  223. {
  224.     if (!ps5_vram_page)
  225.     {
  226.         if (offset < 0x1000)
  227.             psychic5_bgvideoram_w(offset,data);
  228.         else
  229.             ps5_dummy_bg_ram[offset & 0xfff] = data;
  230.     } else
  231.     {
  232.         if (offset < 0x400)
  233.         {
  234.             ps5_io_ram[offset] = data;
  235.         }
  236.         else if (offset < 0x600)
  237.         {
  238.             psychic5_paletteram_w(000, offset-0x400, data);
  239.         }
  240.         else if (offset > 0x5ff && offset< 0x800)
  241.         {
  242.             ps5_palette_ram[offset-0x400] = data;
  243.         }
  244.         else if (offset > 0x7ff && offset < 0xa00)
  245.         {
  246.             psychic5_paletteram_w(256, offset-0x400, data);
  247.         }
  248.         else if (offset > 0x9ff && offset < 0xc00)
  249.         {
  250.             psychic5_paletteram_w(256, offset-0x400, data);
  251.         }
  252.         else if (offset < 0x1000)
  253.         {
  254.             ps5_palette_ram[offset-0x400] = data;
  255.         }
  256.         else
  257.         {
  258.             ps5_foreground_videoram[offset & 0xfff] = data;
  259.         }
  260.     }
  261. }
  262.  
  263.  
  264. int psychic5_vh_start(void)
  265. {
  266.     if ((ps5_background_videoram = malloc(0x1000)) == 0)
  267.     {
  268.         return 1;
  269.     }
  270.     if ((ps5_dummy_bg_ram = malloc(0x1000)) == 0)
  271.     {
  272.         free(ps5_background_videoram);
  273.         return 1;
  274.     }
  275.     if ((ps5_io_ram = malloc(0x400)) == 0)
  276.     {
  277.         free(ps5_background_videoram);
  278.         free(ps5_dummy_bg_ram);
  279.         return 1;
  280.     }
  281.     if ((ps5_palette_ram = malloc(0xc00)) == 0)
  282.     {
  283.         free(ps5_background_videoram);
  284.         free(ps5_dummy_bg_ram);
  285.         free(ps5_io_ram);
  286.         return 1;
  287.     }
  288.     if ((ps5_foreground_videoram = malloc(0x1000)) == 0)
  289.     {
  290.         free(ps5_background_videoram);
  291.         free(ps5_dummy_bg_ram);
  292.         free(ps5_io_ram);
  293.         free(ps5_palette_ram);
  294.         return 1;
  295.     }
  296.         if ((bg_dirtybuffer = malloc(32*64)) == 0)
  297.     {
  298.         free(ps5_background_videoram);
  299.         free(ps5_dummy_bg_ram);
  300.         free(ps5_io_ram);
  301.         free(ps5_palette_ram);
  302.         free(ps5_foreground_videoram);
  303.             return 1;
  304.     }
  305.     if ((bitmap_bg = osd_new_bitmap (Machine->drv->screen_width*4,Machine->drv->screen_height*2,Machine->scrbitmap->depth)) == 0)
  306.     {
  307.         free(ps5_background_videoram);
  308.         free(ps5_dummy_bg_ram);
  309.         free(ps5_io_ram);
  310.         free(ps5_palette_ram);
  311.         free(ps5_foreground_videoram);
  312.         free(bg_dirtybuffer);
  313.         return 1;
  314.     }
  315.         memset(bg_dirtybuffer,1,32*64);
  316.     memset(ps5_background_videoram, 0,0x1000);
  317.     memset(ps5_dummy_bg_ram,0,0x1000);
  318.     memset(ps5_io_ram,0,0x400);
  319.     memset(ps5_palette_ram,0,0xc00);
  320.     memset(ps5_foreground_videoram,0,0x1000);
  321.         return 0;
  322. }
  323.  
  324. void psychic5_vh_stop(void)
  325. {
  326.     free(ps5_background_videoram);
  327.     free(ps5_dummy_bg_ram);
  328.     free(ps5_io_ram);
  329.     free(ps5_palette_ram);
  330.     free(ps5_foreground_videoram);
  331.     free(bg_dirtybuffer);
  332.     osd_free_bitmap(bitmap_bg);
  333. }
  334.  
  335. void psychic5_draw_background(struct osd_bitmap *bitmap)
  336. {
  337.     int x,y,offs;
  338.     int sx,sy,tile,palette,flipx,flipy,lo,hi;
  339.  
  340.     /* for every character in the Video RAM, check if it has been modified */
  341.     /* since last time and update it accordingly. */
  342.  
  343.     for (x = 31; x >=0; x--)
  344.     {
  345.         for (y = 0 ; y < 64; y++)
  346.         {
  347.             offs = y*64+(x*2);
  348.             if (bg_dirtybuffer[offs >> 1])
  349.             {
  350.                 sx = y << 4;
  351.                 sy = x << 4;
  352.  
  353.                 bg_dirtybuffer[offs >> 1] = 0;
  354.  
  355.                 lo = ps5_background_videoram[offs];
  356.                 hi = ps5_background_videoram[offs+1];
  357.                 tile = ((hi & 0xc0) << 2) | lo;
  358.                 flipx = hi & 0x10;
  359.                 flipy = hi & 0x20;
  360.                 palette = hi & 0x0f;
  361.                 drawgfx(bitmap,Machine->gfx[1],
  362.                           tile,
  363.                           palette,
  364.                           flipx,flipy,
  365.                           sx,sy,
  366.                           0,TRANSPARENCY_NONE,0);
  367.             }
  368.         }
  369.     }
  370. }
  371.  
  372. void psychic5_draw_foreground(struct osd_bitmap *bitmap)
  373. {
  374.     int x,y,offs;
  375.     int sx,sy,tile,palette,flipx,flipy,lo,hi;
  376.  
  377.     /* Draw the foreground text */
  378.  
  379.     for (x = 31; x >=0; x--)
  380.     {
  381.         for (y = 0; y < 32; y++)
  382.         {
  383.             offs = y*64+(x*2);
  384.             if (ps5_foreground_videoram[offs+1]!=0xFF)
  385.             {
  386.                 sx = y << 3;
  387.                 sy = x << 3;
  388.  
  389.                 lo = ps5_foreground_videoram[offs];
  390.                 hi = ps5_foreground_videoram[offs+1];
  391.                 tile = ((hi & 0xc0) << 2) | lo;
  392.                 flipx = hi & 0x10;
  393.                 flipy = hi & 0x20;
  394.                 palette = hi & 0x0f;
  395.  
  396.                 drawgfx(bitmap,Machine->gfx[2],
  397.                             tile,
  398.                             palette,
  399.                             flipx,flipy,
  400.                             sx,sy,
  401.                             &Machine->drv->visible_area,TRANSPARENCY_PEN, 15);
  402.             }
  403.         }
  404.     }
  405. }
  406.  
  407. void psychic5_draw_sprites(struct osd_bitmap *bitmap)
  408. {
  409.     int offs,sx,sy,tile,palette,flipx,flipy;
  410.     int size32,tileofs0,tileofs1,tileofs2,tileofs3,temp1,temp2;
  411.  
  412.     /* Draw the sprites */
  413.  
  414.     for (offs = 11 ;offs < spriteram_size; offs+=16)
  415.     {
  416.         if (!(spriteram[offs+4]==0 && spriteram[offs]==0xf0))
  417.         {
  418.             sx = spriteram[offs+1];
  419.             sy = spriteram[offs];
  420.             if (spriteram[offs+2] & 0x01) sx-=256;
  421.             if (spriteram[offs+2] & 0x04) sy-=256;
  422.             tile     = spriteram[offs+3]+((spriteram[offs+2] & 0xc0)<<2);
  423.             size32     = spriteram[offs+2] & 0x08;
  424.             flipx     = spriteram[offs+2] & 0x20;
  425.             flipy     = spriteram[offs+2] & 0x10;
  426.             palette     = spriteram[offs+4] & 0x0f;
  427.             if (flipx)
  428.             {
  429.                 tileofs0 = 1;
  430.                 tileofs1 = 0;
  431.                 tileofs2 = 3;
  432.                 tileofs3 = 2;
  433.             } else
  434.             {
  435.                 tileofs0 = 0;
  436.                 tileofs1 = 1;
  437.                 tileofs2 = 2;
  438.                 tileofs3 = 3;
  439.             }
  440.             if (flipy)
  441.             {
  442.                 temp1     = tileofs0;
  443.                 temp2     = tileofs1;
  444.                 tileofs0 = tileofs2;
  445.                 tileofs1 = tileofs3;
  446.                 tileofs2 = temp1;
  447.                 tileofs3 = temp2;
  448.             }
  449.             if (size32)
  450.             {
  451.                 drawgfx(bitmap,Machine->gfx[0],
  452.                             tile+tileofs0,
  453.                             palette,
  454.                             flipy,flipx,
  455.                             sx,sy,
  456.                             &Machine->drv->visible_area,
  457.                             TRANSPARENCY_PEN, 15);
  458.                 drawgfx(bitmap,Machine->gfx[0],
  459.                             tile+tileofs1,
  460.                             palette,
  461.                             flipy,flipx,
  462.                             sx,sy+16,
  463.                             &Machine->drv->visible_area,
  464.                             TRANSPARENCY_PEN, 15);
  465.                 drawgfx(bitmap,Machine->gfx[0],
  466.                             tile+tileofs2,
  467.                             palette,
  468.                             flipy,flipx,
  469.                             sx+16,sy,
  470.                             &Machine->drv->visible_area,
  471.                             TRANSPARENCY_PEN, 15);
  472.                 drawgfx(bitmap,Machine->gfx[0],
  473.                             tile+tileofs3,
  474.                             palette,
  475.                             flipy,flipx,
  476.                             sx+16,sy+16,
  477.                             &Machine->drv->visible_area,
  478.                             TRANSPARENCY_PEN, 15);
  479.             }
  480.             else
  481.             {
  482.                 drawgfx(bitmap,Machine->gfx[0],
  483.                             tile,
  484.                             palette,
  485.                             flipy,flipx,
  486.                             sx,sy,
  487.                             &Machine->drv->visible_area,
  488.                             TRANSPARENCY_PEN, 15);
  489.             }
  490.         }
  491.     }
  492. }
  493.  
  494.  
  495.  
  496.  
  497. void psychic5_draw_sprites2(struct osd_bitmap *bitmap)
  498. {
  499.     int offs,sx,sy,tile,palette,flipx,flipy;
  500.     int size32,tileofs0,tileofs1,tileofs2,tileofs3;
  501.  
  502.     for (offs = 11 ;offs < spriteram_size; offs+=16)
  503.     {
  504.         if (!(spriteram[offs+4]==0 && spriteram[offs]==0xf0))
  505.         {
  506.             sx = spriteram[offs+1];
  507.             sy = spriteram[offs];
  508.             if (spriteram[offs+2] & 0x01) sx-=256;
  509.             if (spriteram[offs+2] & 0x04) sy-=256;
  510.             tile     = spriteram[offs+3]+((spriteram[offs+2] & 0xc0)<<2);
  511.             size32     = spriteram[offs+2] & 0x08;
  512.             flipx     = spriteram[offs+2] & 0x20;
  513.             flipy     = spriteram[offs+2] & 0x10;
  514.             palette     = spriteram[offs+4] & 0x0;
  515.             tileofs0 = 0;
  516.             tileofs1 = 1;
  517.             tileofs2 = 2;
  518.             tileofs3 = 3;
  519.             if (size32)
  520.             {
  521.                 drawgfx(bitmap,Machine->gfx[0],
  522.                             tile+tileofs0,
  523.                             palette,
  524.                             flipy,flipx,
  525.                             sx,sy,
  526.                             &Machine->drv->visible_area,
  527.                             TRANSPARENCY_NONE, 0);
  528.                 drawgfx(bitmap,Machine->gfx[0],
  529.                             tile+tileofs1,
  530.                             palette,
  531.                             flipy,flipx,
  532.                             sx,sy+16,
  533.                             &Machine->drv->visible_area,
  534.                             TRANSPARENCY_NONE, 0);
  535.                 drawgfx(bitmap,Machine->gfx[0],
  536.                             tile+tileofs2,
  537.                             palette,
  538.                             flipy,flipx,
  539.                             sx+16,sy,
  540.                             &Machine->drv->visible_area,
  541.                             TRANSPARENCY_NONE, 0);
  542.                 drawgfx(bitmap,Machine->gfx[0],
  543.                             tile+tileofs3,
  544.                             palette,
  545.                             flipy,flipx,
  546.                             sx+16,sy+16,
  547.                             &Machine->drv->visible_area,
  548.                             TRANSPARENCY_NONE, 0);
  549.             }
  550.         }
  551.     }
  552. }
  553.  
  554.  
  555.  
  556.  
  557.  
  558. void set_visible_colors(int bg_scrollx,int bg_scrolly)
  559. {
  560.     int x,y,color,offs,lo,hi,tile,size32;
  561.     unsigned short colors_used[16];
  562.  
  563.     palette_init_used_colors();
  564.  
  565.     /* visible background palette */
  566.     memset (colors_used, 0, sizeof (colors_used));
  567.     for (x = 23; x >=0; x--)
  568.     {
  569.         for (y = 0 ; y < 24; y++)
  570.         {
  571.             offs = (((bg_scrollx+y-3) & 63)*64)+(((bg_scrolly+x-3) & 31)*2);
  572.             lo = ps5_background_videoram[offs];
  573.             hi = ps5_background_videoram[offs+1];
  574.             tile = ((hi & 0xc0) << 2) | lo;
  575.             color = hi & 0x0f;
  576.             colors_used[color] |= Machine->gfx[1]->pen_usage[tile];
  577.             if (y<4 || y>19 || x<4 || x>19)
  578.                 bg_dirtybuffer[offs >> 1] = 1;
  579.         }
  580.     }
  581.     for (x = 0; x < 16; x++)
  582.     {
  583.         unsigned short temp = colors_used[x];
  584.         if (temp)
  585.             for (y = 0; y < 16; y++)
  586.                 if (temp & (1 << y)) palette_used_colors[256 + 16 * x + y] = PALETTE_COLOR_USED;
  587.     }
  588.  
  589.     /* visible foreground palette */
  590.     memset (colors_used, 0, sizeof (colors_used));
  591.     for (offs = 0; offs < 0x800; offs+=2)
  592.     {
  593.         if (ps5_foreground_videoram[offs+1]!=0xFF)
  594.         {
  595.             lo = ps5_foreground_videoram[offs];
  596.             hi = ps5_foreground_videoram[offs+1];
  597.             tile = ((hi & 0xc0) << 2) | lo;
  598.             color = hi & 0x0f;
  599.             colors_used[color] |= Machine->gfx[2]->pen_usage[tile];
  600.         }
  601.     }
  602.     for (x = 0; x < 16; x++)
  603.     {
  604.         unsigned short temp = colors_used[x];
  605.         if (temp)
  606.         {
  607.             for (y = 0; y < 15; y++)
  608.                 if (temp & (1 << y)) palette_used_colors[512 + 16 * x + y] = PALETTE_COLOR_USED;
  609.             palette_used_colors[512 + 16 * x + 15] = PALETTE_COLOR_TRANSPARENT;
  610.         }
  611.     }
  612.  
  613.     /* visible sprites palette */
  614.     memset (colors_used, 0, sizeof (colors_used));
  615.     for (offs = 11; offs < spriteram_size; offs += 16)
  616.     {
  617.         if (!(spriteram[offs+4]==0 && spriteram[offs]==0xf0))
  618.         {
  619.             tile     = spriteram[offs+3]+((spriteram[offs+2] & 0xc0)<<2);
  620.             color     = spriteram[offs+4] & 0x0f;
  621.             size32     = spriteram[offs+2] & 0x08;
  622.             if (size32)
  623.                 colors_used[color] |=
  624.                     Machine->gfx[0]->pen_usage[tile+0] |
  625.                     Machine->gfx[0]->pen_usage[tile+1] |
  626.                     Machine->gfx[0]->pen_usage[tile+2] |
  627.                     Machine->gfx[0]->pen_usage[tile+3];
  628.             else
  629.                 colors_used[color] |= Machine->gfx[0]->pen_usage[tile];
  630.         }
  631.     }
  632.     for (x = 0; x < 16; x++)
  633.     {
  634.         unsigned short temp = colors_used[x];
  635.         if (temp)
  636.         {
  637.             for (y = 0; y < 15; y++)
  638.                 if (temp & (1 << y)) palette_used_colors[0 + 16 * x + y] = PALETTE_COLOR_USED;
  639.             palette_used_colors[0 + 16 * x + 15] = PALETTE_COLOR_TRANSPARENT;
  640.         }
  641.     }
  642. }
  643.  
  644. void psychic5_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  645. {
  646.     int bg_scrollx,bg_scrolly;
  647.  
  648.     bg_scrollx = ((ps5_io_ram[BG_SCROLLX_LSB]+((ps5_io_ram[BG_SCROLLX_MSB] & 3)*256)) & 0x3FF) >> 4;
  649.     bg_scrolly = ((ps5_io_ram[BG_SCROLLY_LSB]+((ps5_io_ram[BG_SCROLLY_MSB] & 1)*256)) & 0x1FF) >> 4;
  650.  
  651.     set_visible_colors(bg_scrollx,bg_scrolly);
  652.     set_background_palette_intensity();
  653.  
  654.     if (palette_recalc())
  655.     {
  656.         /* set bg dirty buffer only on visible area + border */
  657.         int offs,x,y;
  658.         for (x = 23; x >=0; x--)
  659.         {
  660.             for (y = 0 ; y < 24; y++)
  661.             {
  662.                 offs = (((bg_scrollx+y-3) & 63)*64)+(((bg_scrolly+x-3) & 31)*2);
  663.                 bg_dirtybuffer[offs >> 1] = 1;
  664.             }
  665.         }
  666.     }
  667.  
  668.     bg_scrollx = -((ps5_io_ram[BG_SCROLLX_LSB]+((ps5_io_ram[BG_SCROLLX_MSB] & 3)*256)) & 0x3FF);
  669.     bg_scrolly = -((ps5_io_ram[BG_SCROLLY_LSB]+((ps5_io_ram[BG_SCROLLY_MSB] & 1)*256)) & 0x1FF);
  670.  
  671.     if (ps5_io_ram[BG_SCREEN_MODE] & 1)  /* background enable */
  672.     {
  673.         psychic5_draw_background(bitmap_bg);
  674.  
  675.         if (is_psychic5_title_mode())
  676.         {
  677.             struct rectangle clip;
  678.             int sx1,sy1,sy2,tile;
  679.  
  680.             sx1  = spriteram[12];        /* sprite 0 */
  681.             sy1  = spriteram[11];
  682.             tile = spriteram[14];
  683.             sy2 = spriteram[11+128];    /* sprite 8 */
  684.  
  685.             clip.min_x = Machine->drv->visible_area.min_x;
  686.             clip.min_y = Machine->drv->visible_area.min_y;
  687.             clip.max_x = Machine->drv->visible_area.max_x;
  688.             clip.max_y = Machine->drv->visible_area.max_y;
  689.  
  690.             if (bg_clip_mode >=0 && bg_clip_mode < 3 && sy1==240) bg_clip_mode = 0;
  691.             if (bg_clip_mode > 2 && bg_clip_mode < 5 && sy2==240) bg_clip_mode = -10;
  692.             if (bg_clip_mode > 4 && bg_clip_mode < 7 && sx1==240) bg_clip_mode = 0;
  693.             if (bg_clip_mode > 6 && bg_clip_mode < 9 && (sx1==240 || sx1==0)) bg_clip_mode = -10;
  694.  
  695.             if (sy1!=240 && sy1!=0 && bg_clip_mode<=0)
  696.             {
  697.                 if (sy1>128)
  698.                  bg_clip_mode=1;
  699.                 else
  700.                  bg_clip_mode=2;
  701.             }
  702.             if (sy2!=240 && sy2!=0 && bg_clip_mode<=0)
  703.             {
  704.                 if (sy2>128)
  705.                  bg_clip_mode=3;
  706.                 else
  707.                  bg_clip_mode=4;
  708.             }
  709.             if (sx1!=240 && sx1!=0 && bg_clip_mode<=0 && tile==0x3c)
  710.             {
  711.                 if (sx1>128)
  712.                  bg_clip_mode=5;
  713.                 else
  714.                  bg_clip_mode=6;
  715.             }
  716.             if (sx1!=240 && sx1!=0 && bg_clip_mode<=0 && tile==0x1c)
  717.             {
  718.                 if (sx1>128)
  719.                  bg_clip_mode=7;
  720.                 else
  721.                  bg_clip_mode=8;
  722.             }
  723.             if (bg_clip_mode)
  724.             {
  725.                 if (bg_clip_mode==1)
  726.                  clip.min_y = sy1;
  727.                 else if (bg_clip_mode==2)
  728.                   clip.max_y = sy1;
  729.                 else if (bg_clip_mode==3)
  730.                  clip.max_y = sy2;
  731.                 else if (bg_clip_mode==4)
  732.                  clip.min_y = sy2;
  733.                 else if (bg_clip_mode==5)
  734.                  clip.min_x = sx1;
  735.                 else if (bg_clip_mode==6)
  736.                   clip.max_x = sx1;
  737.                 else if (bg_clip_mode==7)
  738.                  clip.max_x = sx1;
  739.                 else if (bg_clip_mode==8)
  740.                  clip.min_x = sx1;
  741.                 else if (bg_clip_mode==-10)
  742.                 {
  743.                     clip.min_x = 0;
  744.                     clip.min_y = 0;
  745.                     clip.max_x = 0;
  746.                     clip.max_y = 0;
  747.                 }
  748.                 fillbitmap(bitmap,palette_transparent_pen,&Machine->drv->visible_area);
  749.                 copyscrollbitmap(bitmap,bitmap_bg,1,&bg_scrollx,1,&bg_scrolly,&clip,TRANSPARENCY_NONE,0);
  750.             } else
  751.                 copyscrollbitmap(bitmap,bitmap_bg,1,&bg_scrollx,1,&bg_scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  752.  
  753.         } else
  754.             copyscrollbitmap(bitmap,bitmap_bg,1,&bg_scrollx,1,&bg_scrolly,&Machine->drv->visible_area,TRANSPARENCY_NONE,0);
  755.     } else
  756.     {
  757.         fillbitmap(bitmap,palette_transparent_pen,&Machine->drv->visible_area);
  758.         memset(bg_dirtybuffer,1,64*32);
  759.     }
  760.  
  761.     if (!is_psychic5_title_mode())
  762.     {
  763.         psychic5_draw_sprites(bitmap);
  764.         bg_clip_mode=-10;
  765.     }
  766.     psychic5_draw_foreground(bitmap);
  767. }
  768.